<?php
    /** PHPExcel root directory */
    if (!defined('PHPEXCEL_ROOT')) {
        /**
         * @ignore
         */
        define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
        require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
    }

    /**
     * PHPExcel_Calculation_MathTrig
     * Copyright (c) 2006 - 2015 PHPExcel
     * This library is free software; you can redistribute it and/or
     * modify it under the terms of the GNU Lesser General Public
     * License as published by the Free Software Foundation; either
     * version 2.1 of the License, or (at your option) any later version.
     * This library is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
     * Lesser General Public License for more details.
     * You should have received a copy of the GNU Lesser General Public
     * License along with this library; if not, write to the Free Software
     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
     * @category       PHPExcel
     * @package        PHPExcel_Calculation
     * @copyright      Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
     * @license        http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
     * @version        ##VERSION##, ##DATE##
     */
    class PHPExcel_Calculation_MathTrig {
        //
        //    Private method to return an array of the factors of the input value
        //
        /**
         * ATAN2
         * This function calculates the arc tangent of the two variables x and y. It is similar to
         *        calculating the arc tangent of y ÷ x, except that the signs of both arguments are used
         *        to determine the quadrant of the result.
         * The arctangent is the angle from the x-axis to a line containing the origin (0, 0) and a
         *        point with coordinates (xCoordinate, yCoordinate). The angle is given in radians between
         *        -pi and pi, excluding -pi.
         * Note that the Excel ATAN2() function accepts its arguments in the reverse order to the standard
         *        PHP atan2() function, so we need to reverse them here before calling the PHP atan() function.
         * Excel Function:
         *        ATAN2(xCoordinate,yCoordinate)
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    float $xCoordinate The x-coordinate of the point.
         * @param    float $yCoordinate The y-coordinate of the point.
         * @return    float    The inverse tangent of the specified x- and y-coordinates.
         */
        public static function ATAN2($xCoordinate = null, $yCoordinate = null) {
            $xCoordinate = PHPExcel_Calculation_Functions::flattenSingleValue($xCoordinate);
            $yCoordinate = PHPExcel_Calculation_Functions::flattenSingleValue($yCoordinate);
            $xCoordinate = ($xCoordinate !== null) ? $xCoordinate : 0.0;
            $yCoordinate = ($yCoordinate !== null) ? $yCoordinate : 0.0;
            if (((is_numeric($xCoordinate)) || (is_bool($xCoordinate))) && ((is_numeric($yCoordinate))) || (is_bool($yCoordinate))) {
                $xCoordinate = (float)$xCoordinate;
                $yCoordinate = (float)$yCoordinate;
                if (($xCoordinate == 0) && ($yCoordinate == 0)) {
                    return PHPExcel_Calculation_Functions::DIV0();
                }
                return atan2($yCoordinate, $xCoordinate);
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * COMBIN
         * Returns the number of combinations for a given number of items. Use COMBIN to
         *        determine the total possible number of groups for a given number of items.
         * Excel Function:
         *        COMBIN(numObjs,numInSet)
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    int $numObjs  Number of different objects
         * @param    int $numInSet Number of objects in each combination
         * @return    int        Number of combinations
         */
        public static function COMBIN($numObjs, $numInSet) {
            $numObjs  = PHPExcel_Calculation_Functions::flattenSingleValue($numObjs);
            $numInSet = PHPExcel_Calculation_Functions::flattenSingleValue($numInSet);
            if ((is_numeric($numObjs)) && (is_numeric($numInSet))) {
                if ($numObjs < $numInSet) {
                    return PHPExcel_Calculation_Functions::NaN();
                } elseif ($numInSet < 0) {
                    return PHPExcel_Calculation_Functions::NaN();
                }
                return round(self::FACT($numObjs) / self::FACT($numObjs - $numInSet)) / self::FACT($numInSet);
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * FACT
         * Returns the factorial of a number.
         * The factorial of a number is equal to 1*2*3*...* number.
         * Excel Function:
         *        FACT(factVal)
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    float $factVal Factorial Value
         * @return    int        Factorial
         */
        public static function FACT($factVal) {
            $factVal = PHPExcel_Calculation_Functions::flattenSingleValue($factVal);
            if (is_numeric($factVal)) {
                if ($factVal < 0) {
                    return PHPExcel_Calculation_Functions::NaN();
                }
                $factLoop = floor($factVal);
                if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
                    if ($factVal > $factLoop) {
                        return PHPExcel_Calculation_Functions::NaN();
                    }
                }
                $factorial = 1;
                while ($factLoop > 1) {
                    $factorial *= $factLoop--;
                }
                return $factorial;
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * FACTDOUBLE
         * Returns the double factorial of a number.
         * Excel Function:
         *        FACTDOUBLE(factVal)
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    float $factVal Factorial Value
         * @return    int        Double Factorial
         */
        public static function FACTDOUBLE($factVal) {
            $factLoop = PHPExcel_Calculation_Functions::flattenSingleValue($factVal);
            if (is_numeric($factLoop)) {
                $factLoop = floor($factLoop);
                if ($factVal < 0) {
                    return PHPExcel_Calculation_Functions::NaN();
                }
                $factorial = 1;
                while ($factLoop > 1) {
                    $factorial *= $factLoop--;
                    --$factLoop;
                }
                return $factorial;
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * FLOOR
         * Rounds number down, toward zero, to the nearest multiple of significance.
         * Excel Function:
         *        FLOOR(number[,significance])
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    float $number       Number to round
         * @param    float $significance Significance
         * @return    float    Rounded Number
         */
        public static function FLOOR($number, $significance = null) {
            $number       = PHPExcel_Calculation_Functions::flattenSingleValue($number);
            $significance = PHPExcel_Calculation_Functions::flattenSingleValue($significance);
            if ((is_null($significance)) && (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC)) {
                $significance = $number / abs($number);
            }
            if ((is_numeric($number)) && (is_numeric($significance))) {
                if ($significance == 0.0) {
                    return PHPExcel_Calculation_Functions::DIV0();
                } elseif ($number == 0.0) {
                    return 0.0;
                } elseif (self::SIGN($number) == self::SIGN($significance)) {
                    return floor($number / $significance) * $significance;
                } else {
                    return PHPExcel_Calculation_Functions::NaN();
                }
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * SIGN
         * Determines the sign of a number. Returns 1 if the number is positive, zero (0)
         *        if the number is 0, and -1 if the number is negative.
         * @param    float $number Number to round
         * @return    int        sign value
         */
        public static function SIGN($number) {
            $number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
            if (is_bool($number)) {
                return (int)$number;
            }
            if (is_numeric($number)) {
                if ($number == 0.0) {
                    return 0;
                }
                return $number / abs($number);
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * GCD
         * Returns the greatest common divisor of a series of numbers.
         * The greatest common divisor is the largest integer that divides both
         *        number1 and number2 without a remainder.
         * Excel Function:
         *        GCD(number1[,number2[, ...]])
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    mixed $arg,... Data values
         * @return    integer                    Greatest Common Divisor
         */
        public static function GCD() {
            $returnValue      = 1;
            $allValuesFactors = [];
            // Loop through arguments
            foreach (PHPExcel_Calculation_Functions::flattenArray(func_get_args()) as $value) {
                if (!is_numeric($value)) {
                    return PHPExcel_Calculation_Functions::VALUE();
                } elseif ($value == 0) {
                    continue;
                } elseif ($value < 0) {
                    return PHPExcel_Calculation_Functions::NaN();
                }
                $myFactors          = self::factors($value);
                $myCountedFactors   = array_count_values($myFactors);
                $allValuesFactors[] = $myCountedFactors;
            }
            $allValuesCount = count($allValuesFactors);
            if ($allValuesCount == 0) {
                return 0;
            }
            $mergedArray = $allValuesFactors[0];
            for ($i = 1; $i < $allValuesCount; ++$i) {
                $mergedArray = array_intersect_key($mergedArray, $allValuesFactors[$i]);
            }
            $mergedArrayValues = count($mergedArray);
            if ($mergedArrayValues == 0) {
                return $returnValue;
            } elseif ($mergedArrayValues > 1) {
                foreach ($mergedArray as $mergedKey => $mergedValue) {
                    foreach ($allValuesFactors as $highestPowerTest) {
                        foreach ($highestPowerTest as $testKey => $testValue) {
                            if (($testKey == $mergedKey) && ($testValue < $mergedValue)) {
                                $mergedArray[$mergedKey] = $testValue;
                                $mergedValue             = $testValue;
                            }
                        }
                    }
                }
                $returnValue = 1;
                foreach ($mergedArray as $key => $value) {
                    $returnValue *= pow($key, $value);
                }
                return $returnValue;
            } else {
                $keys  = array_keys($mergedArray);
                $key   = $keys[0];
                $value = $mergedArray[$key];
                foreach ($allValuesFactors as $testValue) {
                    foreach ($testValue as $mergedKey => $mergedValue) {
                        if (($mergedKey == $key) && ($mergedValue < $value)) {
                            $value = $mergedValue;
                        }
                    }
                }
                return pow($key, $value);
            }
        }

        private static function factors($value) {
            $startVal = floor(sqrt($value));
            $factorArray = [];
            for ($i = $startVal; $i > 1; --$i) {
                if (($value % $i) == 0) {
                    $factorArray = array_merge($factorArray, self::factors($value / $i));
                    $factorArray = array_merge($factorArray, self::factors($i));
                    if ($i <= sqrt($value)) {
                        break;
                    }
                }
            }
            if (!empty($factorArray)) {
                rsort($factorArray);
                return $factorArray;
            } else {
                return [(integer)$value];
            }
        }

        /**
         * INT
         * Casts a floating point value to an integer
         * Excel Function:
         *        INT(number)
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    float $number Number to cast to an integer
         * @return    integer    Integer value
         */
        public static function INT($number) {
            $number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
            if (is_null($number)) {
                return 0;
            } elseif (is_bool($number)) {
                return (int)$number;
            }
            if (is_numeric($number)) {
                return (int)floor($number);
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * LCM
         * Returns the lowest common multiplier of a series of numbers
         * The least common multiple is the smallest positive integer that is a multiple
         * of all integer arguments number1, number2, and so on. Use LCM to add fractions
         * with different denominators.
         * Excel Function:
         *        LCM(number1[,number2[, ...]])
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    mixed $arg,... Data values
         * @return    int        Lowest Common Multiplier
         */
        public static function LCM() {
            $returnValue       = 1;
            $allPoweredFactors = [];
            // Loop through arguments
            foreach (PHPExcel_Calculation_Functions::flattenArray(func_get_args()) as $value) {
                if (!is_numeric($value)) {
                    return PHPExcel_Calculation_Functions::VALUE();
                }
                if ($value == 0) {
                    return 0;
                } elseif ($value < 0) {
                    return PHPExcel_Calculation_Functions::NaN();
                }
                $myFactors        = self::factors(floor($value));
                $myCountedFactors = array_count_values($myFactors);
                $myPoweredFactors = [];
                foreach ($myCountedFactors as $myCountedFactor => $myCountedPower) {
                    $myPoweredFactors[$myCountedFactor] = pow($myCountedFactor, $myCountedPower);
                }
                foreach ($myPoweredFactors as $myPoweredValue => $myPoweredFactor) {
                    if (array_key_exists($myPoweredValue, $allPoweredFactors)) {
                        if ($allPoweredFactors[$myPoweredValue] < $myPoweredFactor) {
                            $allPoweredFactors[$myPoweredValue] = $myPoweredFactor;
                        }
                    } else {
                        $allPoweredFactors[$myPoweredValue] = $myPoweredFactor;
                    }
                }
            }
            foreach ($allPoweredFactors as $allPoweredFactor) {
                $returnValue *= (integer)$allPoweredFactor;
            }
            return $returnValue;
        }

        /**
         * LOG_BASE
         * Returns the logarithm of a number to a specified base. The default base is 10.
         * Excel Function:
         *        LOG(number[,base])
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    float $number The positive real number for which you want the logarithm
         * @param    float $base   The base of the logarithm. If base is omitted, it is assumed to be 10.
         * @return    float
         */
        public static function LOG_BASE($number = null, $base = 10) {
            $number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
            $base   = (is_null($base)) ? 10 : (float)PHPExcel_Calculation_Functions::flattenSingleValue($base);
            if ((!is_numeric($base)) || (!is_numeric($number))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            if (($base <= 0) || ($number <= 0)) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            return log($number, $base);
        }

        /**
         * MDETERM
         * Returns the matrix determinant of an array.
         * Excel Function:
         *        MDETERM(array)
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    array $matrixValues A matrix of values
         * @return    float
         */
        public static function MDETERM($matrixValues) {
            $matrixData = [];
            if (!is_array($matrixValues)) {
                $matrixValues = [[$matrixValues]];
            }
            $row = $maxColumn = 0;
            foreach ($matrixValues as $matrixRow) {
                if (!is_array($matrixRow)) {
                    $matrixRow = [$matrixRow];
                }
                $column = 0;
                foreach ($matrixRow as $matrixCell) {
                    if ((is_string($matrixCell)) || ($matrixCell === null)) {
                        return PHPExcel_Calculation_Functions::VALUE();
                    }
                    $matrixData[$column][$row] = $matrixCell;
                    ++$column;
                }
                if ($column > $maxColumn) {
                    $maxColumn = $column;
                }
                ++$row;
            }
            if ($row != $maxColumn) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            try {
                $matrix = new PHPExcel_Shared_JAMA_Matrix($matrixData);
                return $matrix->det();
            } catch (PHPExcel_Exception $ex) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
        }

        /**
         * MINVERSE
         * Returns the inverse matrix for the matrix stored in an array.
         * Excel Function:
         *        MINVERSE(array)
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    array $matrixValues A matrix of values
         * @return    array
         */
        public static function MINVERSE($matrixValues) {
            $matrixData = [];
            if (!is_array($matrixValues)) {
                $matrixValues = [[$matrixValues]];
            }
            $row = $maxColumn = 0;
            foreach ($matrixValues as $matrixRow) {
                if (!is_array($matrixRow)) {
                    $matrixRow = [$matrixRow];
                }
                $column = 0;
                foreach ($matrixRow as $matrixCell) {
                    if ((is_string($matrixCell)) || ($matrixCell === null)) {
                        return PHPExcel_Calculation_Functions::VALUE();
                    }
                    $matrixData[$column][$row] = $matrixCell;
                    ++$column;
                }
                if ($column > $maxColumn) {
                    $maxColumn = $column;
                }
                ++$row;
            }
            if ($row != $maxColumn) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            try {
                $matrix = new PHPExcel_Shared_JAMA_Matrix($matrixData);
                return $matrix->inverse()->getArray();
            } catch (PHPExcel_Exception $ex) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
        }

        /**
         * MMULT
         * @param    array $matrixData1 A matrix of values
         * @param    array $matrixData2 A matrix of values
         * @return    array
         */
        public static function MMULT($matrixData1, $matrixData2) {
            $matrixAData = $matrixBData = [];
            if (!is_array($matrixData1)) {
                $matrixData1 = [[$matrixData1]];
            }
            if (!is_array($matrixData2)) {
                $matrixData2 = [[$matrixData2]];
            }
            try {
                $rowA = 0;
                foreach ($matrixData1 as $matrixRow) {
                    if (!is_array($matrixRow)) {
                        $matrixRow = [$matrixRow];
                    }
                    $columnA = 0;
                    foreach ($matrixRow as $matrixCell) {
                        if ((!is_numeric($matrixCell)) || ($matrixCell === null)) {
                            return PHPExcel_Calculation_Functions::VALUE();
                        }
                        $matrixAData[$rowA][$columnA] = $matrixCell;
                        ++$columnA;
                    }
                    ++$rowA;
                }
                $matrixA = new PHPExcel_Shared_JAMA_Matrix($matrixAData);
                $rowB    = 0;
                foreach ($matrixData2 as $matrixRow) {
                    if (!is_array($matrixRow)) {
                        $matrixRow = [$matrixRow];
                    }
                    $columnB = 0;
                    foreach ($matrixRow as $matrixCell) {
                        if ((!is_numeric($matrixCell)) || ($matrixCell === null)) {
                            return PHPExcel_Calculation_Functions::VALUE();
                        }
                        $matrixBData[$rowB][$columnB] = $matrixCell;
                        ++$columnB;
                    }
                    ++$rowB;
                }
                $matrixB = new PHPExcel_Shared_JAMA_Matrix($matrixBData);
                if ($columnA != $rowB) {
                    return PHPExcel_Calculation_Functions::VALUE();
                }
                return $matrixA->times($matrixB)->getArray();
            } catch (PHPExcel_Exception $ex) {
                var_dump($ex->getMessage());
                return PHPExcel_Calculation_Functions::VALUE();
            }
        }

        /**
         * MOD
         * @param    int $a Dividend
         * @param    int $b Divisor
         * @return    int        Remainder
         */
        public static function MOD($a = 1, $b = 1) {
            $a = PHPExcel_Calculation_Functions::flattenSingleValue($a);
            $b = PHPExcel_Calculation_Functions::flattenSingleValue($b);
            if ($b == 0.0) {
                return PHPExcel_Calculation_Functions::DIV0();
            } elseif (($a < 0.0) && ($b > 0.0)) {
                return $b - fmod(abs($a), $b);
            } elseif (($a > 0.0) && ($b < 0.0)) {
                return $b + fmod($a, abs($b));
            }
            return fmod($a, $b);
        }

        /**
         * MROUND
         * Rounds a number to the nearest multiple of a specified value
         * @param    float $number   Number to round
         * @param    int   $multiple Multiple to which you want to round $number
         * @return    float    Rounded Number
         */
        public static function MROUND($number, $multiple) {
            $number   = PHPExcel_Calculation_Functions::flattenSingleValue($number);
            $multiple = PHPExcel_Calculation_Functions::flattenSingleValue($multiple);
            if ((is_numeric($number)) && (is_numeric($multiple))) {
                if ($multiple == 0) {
                    return 0;
                }
                if ((self::SIGN($number)) == (self::SIGN($multiple))) {
                    $multiplier = 1 / $multiple;
                    return round($number * $multiplier) / $multiplier;
                }
                return PHPExcel_Calculation_Functions::NaN();
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * MULTINOMIAL
         * Returns the ratio of the factorial of a sum of values to the product of factorials.
         * @param    array of mixed        Data Series
         * @return    float
         */
        public static function MULTINOMIAL() {
            $summer  = 0;
            $divisor = 1;
            // Loop through arguments
            foreach (PHPExcel_Calculation_Functions::flattenArray(func_get_args()) as $arg) {
                // Is it a numeric value?
                if (is_numeric($arg)) {
                    if ($arg < 1) {
                        return PHPExcel_Calculation_Functions::NaN();
                    }
                    $summer  += floor($arg);
                    $divisor *= self::FACT($arg);
                } else {
                    return PHPExcel_Calculation_Functions::VALUE();
                }
            }
            // Return
            if ($summer > 0) {
                $summer = self::FACT($summer);
                return $summer / $divisor;
            }
            return 0;
        }

        /**
         * ODD
         * Returns number rounded up to the nearest odd integer.
         * @param    float $number Number to round
         * @return    int        Rounded Number
         */
        public static function ODD($number) {
            $number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
            if (is_null($number)) {
                return 1;
            } elseif (is_bool($number)) {
                return 1;
            } elseif (is_numeric($number)) {
                $significance = self::SIGN($number);
                if ($significance == 0) {
                    return 1;
                }
                $result = self::CEILING($number, $significance);
                if ($result == self::EVEN($result)) {
                    $result += $significance;
                }
                return (int)$result;
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * CEILING
         * Returns number rounded up, away from zero, to the nearest multiple of significance.
         *        For example, if you want to avoid using pennies in your prices and your product is
         *        priced at $4.42, use the formula =CEILING(4.42,0.05) to round prices up to the
         *        nearest nickel.
         * Excel Function:
         *        CEILING(number[,significance])
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    float $number       The number you want to round.
         * @param    float $significance The multiple to which you want to round.
         * @return    float    Rounded Number
         */
        public static function CEILING($number, $significance = null) {
            $number       = PHPExcel_Calculation_Functions::flattenSingleValue($number);
            $significance = PHPExcel_Calculation_Functions::flattenSingleValue($significance);
            if ((is_null($significance)) && (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC)) {
                $significance = $number / abs($number);
            }
            if ((is_numeric($number)) && (is_numeric($significance))) {
                if (($number == 0.0) || ($significance == 0.0)) {
                    return 0.0;
                } elseif (self::SIGN($number) == self::SIGN($significance)) {
                    return ceil($number / $significance) * $significance;
                } else {
                    return PHPExcel_Calculation_Functions::NaN();
                }
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * EVEN
         * Returns number rounded up to the nearest even integer.
         * You can use this function for processing items that come in twos. For example,
         *        a packing crate accepts rows of one or two items. The crate is full when
         *        the number of items, rounded up to the nearest two, matches the crate's
         *        capacity.
         * Excel Function:
         *        EVEN(number)
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    float $number Number to round
         * @return    int        Rounded Number
         */
        public static function EVEN($number) {
            $number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
            if (is_null($number)) {
                return 0;
            } elseif (is_bool($number)) {
                $number = (int)$number;
            }
            if (is_numeric($number)) {
                $significance = 2 * self::SIGN($number);
                return (int)self::CEILING($number, $significance);
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * POWER
         * Computes x raised to the power y.
         * @param    float $x
         * @param    float $y
         * @return    float
         */
        public static function POWER($x = 0, $y = 2) {
            $x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
            $y = PHPExcel_Calculation_Functions::flattenSingleValue($y);
            // Validate parameters
            if ($x == 0.0 && $y == 0.0) {
                return PHPExcel_Calculation_Functions::NaN();
            } elseif ($x == 0.0 && $y < 0.0) {
                return PHPExcel_Calculation_Functions::DIV0();
            }
            // Return
            $result = pow($x, $y);
            return (!is_nan($result) && !is_infinite($result)) ? $result : PHPExcel_Calculation_Functions::NaN();
        }

        /**
         * QUOTIENT
         * QUOTIENT function returns the integer portion of a division. Numerator is the divided number
         *        and denominator is the divisor.
         * Excel Function:
         *        QUOTIENT(value1[,value2[, ...]])
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    mixed $arg,... Data values
         * @return    float
         */
        public static function QUOTIENT() {
            // Return value
            $returnValue = null;
            // Loop through arguments
            foreach (PHPExcel_Calculation_Functions::flattenArray(func_get_args()) as $arg) {
                // Is it a numeric value?
                if ((is_numeric($arg)) && (!is_string($arg))) {
                    if (is_null($returnValue)) {
                        $returnValue = ($arg == 0) ? 0 : $arg;
                    } else {
                        if (($returnValue == 0) || ($arg == 0)) {
                            $returnValue = 0;
                        } else {
                            $returnValue /= $arg;
                        }
                    }
                }
            }
            // Return
            return intval($returnValue);
        }

        /**
         * RAND
         * @param    int $min Minimal value
         * @param    int $max Maximal value
         * @return    int        Random number
         */
        public static function RAND($min = 0, $max = 0) {
            $min = PHPExcel_Calculation_Functions::flattenSingleValue($min);
            $max = PHPExcel_Calculation_Functions::flattenSingleValue($max);
            if ($min == 0 && $max == 0) {
                return (mt_rand(0, 10000000)) / 10000000;
            } else {
                return mt_rand($min, $max);
            }
        }

        public static function ROMAN($aValue, $style = 0) {
            $aValue = PHPExcel_Calculation_Functions::flattenSingleValue($aValue);
            $style  = (is_null($style)) ? 0 : (integer)PHPExcel_Calculation_Functions::flattenSingleValue($style);
            if ((!is_numeric($aValue)) || ($aValue < 0) || ($aValue >= 4000)) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            $aValue = (integer)$aValue;
            if ($aValue == 0) {
                return '';
            }
            $mill = [
                '',
                'M',
                'MM',
                'MMM',
                'MMMM',
                'MMMMM'
            ];
            $cent = [
                '',
                'C',
                'CC',
                'CCC',
                'CD',
                'D',
                'DC',
                'DCC',
                'DCCC',
                'CM'
            ];
            $tens = [
                '',
                'X',
                'XX',
                'XXX',
                'XL',
                'L',
                'LX',
                'LXX',
                'LXXX',
                'XC'
            ];
            $ones = [
                '',
                'I',
                'II',
                'III',
                'IV',
                'V',
                'VI',
                'VII',
                'VIII',
                'IX'
            ];
            $roman = '';
            while ($aValue > 5999) {
                $roman  .= 'M';
                $aValue -= 1000;
            }
            $m      = self::romanCut($aValue, 1000);
            $aValue %= 1000;
            $c      = self::romanCut($aValue, 100);
            $aValue %= 100;
            $t      = self::romanCut($aValue, 10);
            $aValue %= 10;
            return $roman . $mill[$m] . $cent[$c] . $tens[$t] . $ones[$aValue];
        }

        private static function romanCut($num, $n) {
            return ($num - ($num % $n)) / $n;
        }

        /**
         * ROUNDUP
         * Rounds a number up to a specified number of decimal places
         * @param    float $number Number to round
         * @param    int   $digits Number of digits to which you want to round $number
         * @return    float    Rounded Number
         */
        public static function ROUNDUP($number, $digits) {
            $number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
            $digits = PHPExcel_Calculation_Functions::flattenSingleValue($digits);
            if ((is_numeric($number)) && (is_numeric($digits))) {
                $significance = pow(10, (int)$digits);
                if ($number < 0.0) {
                    return floor($number * $significance) / $significance;
                } else {
                    return ceil($number * $significance) / $significance;
                }
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * ROUNDDOWN
         * Rounds a number down to a specified number of decimal places
         * @param    float $number Number to round
         * @param    int   $digits Number of digits to which you want to round $number
         * @return    float    Rounded Number
         */
        public static function ROUNDDOWN($number, $digits) {
            $number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
            $digits = PHPExcel_Calculation_Functions::flattenSingleValue($digits);
            if ((is_numeric($number)) && (is_numeric($digits))) {
                $significance = pow(10, (int)$digits);
                if ($number < 0.0) {
                    return ceil($number * $significance) / $significance;
                } else {
                    return floor($number * $significance) / $significance;
                }
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * SERIESSUM
         * Returns the sum of a power series
         * @param    float $x    Input value to the power series
         * @param    float $n    Initial power to which you want to raise $x
         * @param    float $m    Step by which to increase $n for each term in the series
         * @param          array of mixed        Data Series
         * @return    float
         */
        public static function SERIESSUM() {
            $returnValue = 0;
            // Loop through arguments
            $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
            $x = array_shift($aArgs);
            $n = array_shift($aArgs);
            $m = array_shift($aArgs);
            if ((is_numeric($x)) && (is_numeric($n)) && (is_numeric($m))) {
                // Calculate
                $i = 0;
                foreach ($aArgs as $arg) {
                    // Is it a numeric value?
                    if ((is_numeric($arg)) && (!is_string($arg))) {
                        $returnValue += $arg * pow($x, $n + ($m * $i++));
                    } else {
                        return PHPExcel_Calculation_Functions::VALUE();
                    }
                }
                return $returnValue;
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * SQRTPI
         * Returns the square root of (number * pi).
         * @param    float $number Number
         * @return    float    Square Root of Number * Pi
         */
        public static function SQRTPI($number) {
            $number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
            if (is_numeric($number)) {
                if ($number < 0) {
                    return PHPExcel_Calculation_Functions::NaN();
                }
                return sqrt($number * M_PI);
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * SUBTOTAL
         * Returns a subtotal in a list or database.
         * @param    int        the number 1 to 11 that specifies which function to
         *                      use in calculating subtotals within a list.
         * @param    array      of mixed        Data Series
         * @return    float
         */
        public static function SUBTOTAL() {
            $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
            // Calculate
            $subtotal = array_shift($aArgs);
            if ((is_numeric($subtotal)) && (!is_string($subtotal))) {
                switch ($subtotal) {
                    case 1:
                        return PHPExcel_Calculation_Statistical::AVERAGE($aArgs);
                    case 2:
                        return PHPExcel_Calculation_Statistical::COUNT($aArgs);
                    case 3:
                        return PHPExcel_Calculation_Statistical::COUNTA($aArgs);
                    case 4:
                        return PHPExcel_Calculation_Statistical::MAX($aArgs);
                    case 5:
                        return PHPExcel_Calculation_Statistical::MIN($aArgs);
                    case 6:
                        return self::PRODUCT($aArgs);
                    case 7:
                        return PHPExcel_Calculation_Statistical::STDEV($aArgs);
                    case 8:
                        return PHPExcel_Calculation_Statistical::STDEVP($aArgs);
                    case 9:
                        return self::SUM($aArgs);
                    case 10:
                        return PHPExcel_Calculation_Statistical::VARFunc($aArgs);
                    case 11:
                        return PHPExcel_Calculation_Statistical::VARP($aArgs);
                }
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * PRODUCT
         * PRODUCT returns the product of all the values and cells referenced in the argument list.
         * Excel Function:
         *        PRODUCT(value1[,value2[, ...]])
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    mixed $arg,... Data values
         * @return    float
         */
        public static function PRODUCT() {
            // Return value
            $returnValue = null;
            // Loop through arguments
            foreach (PHPExcel_Calculation_Functions::flattenArray(func_get_args()) as $arg) {
                // Is it a numeric value?
                if ((is_numeric($arg)) && (!is_string($arg))) {
                    if (is_null($returnValue)) {
                        $returnValue = $arg;
                    } else {
                        $returnValue *= $arg;
                    }
                }
            }
            // Return
            if (is_null($returnValue)) {
                return 0;
            }
            return $returnValue;
        }

        /**
         * SUM
         * SUM computes the sum of all the values and cells referenced in the argument list.
         * Excel Function:
         *        SUM(value1[,value2[, ...]])
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    mixed $arg,... Data values
         * @return    float
         */
        public static function SUM() {
            $returnValue = 0;
            // Loop through the arguments
            foreach (PHPExcel_Calculation_Functions::flattenArray(func_get_args()) as $arg) {
                // Is it a numeric value?
                if ((is_numeric($arg)) && (!is_string($arg))) {
                    $returnValue += $arg;
                }
            }
            return $returnValue;
        }

        /**
         * SUMIF
         * Counts the number of cells that contain numbers within the list of arguments
         * Excel Function:
         *        SUMIF(value1[,value2[, ...]],condition)
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    mixed  $arg,...   Data values
         * @param    string $condition The criteria that defines which cells will be summed.
         * @return    float
         */
        public static function SUMIF($aArgs, $condition, $sumArgs = []) {
            $returnValue = 0;
            $aArgs   = PHPExcel_Calculation_Functions::flattenArray($aArgs);
            $sumArgs = PHPExcel_Calculation_Functions::flattenArray($sumArgs);
            if (empty($sumArgs)) {
                $sumArgs = $aArgs;
            }
            $condition = PHPExcel_Calculation_Functions::ifCondition($condition);
            // Loop through arguments
            foreach ($aArgs as $key => $arg) {
                if (!is_numeric($arg)) {
                    $arg = str_replace('"', '""', $arg);
                    $arg = PHPExcel_Calculation::wrapResult(strtoupper($arg));
                }
                $testCondition = '=' . $arg . $condition;
                if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
                    // Is it a value within our criteria
                    $returnValue += $sumArgs[$key];
                }
            }
            return $returnValue;
        }

        /**
         *    SUMIFS
         *    Counts the number of cells that contain numbers within the list of arguments
         *    Excel Function:
         *        SUMIFS(value1[,value2[, ...]],condition)
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    mixed  $arg,...   Data values
         * @param    string $condition The criteria that defines which cells will be summed.
         * @return    float
         */
        public static function SUMIFS() {
            $arrayList = func_get_args();
            $sumArgs = PHPExcel_Calculation_Functions::flattenArray(array_shift($arrayList));
            while (count($arrayList) > 0) {
                $aArgsArray[] = PHPExcel_Calculation_Functions::flattenArray(array_shift($arrayList));
                $conditions[] = PHPExcel_Calculation_Functions::ifCondition(array_shift($arrayList));
            }
            // Loop through each set of arguments and conditions
            foreach ($conditions as $index => $condition) {
                $aArgs    = $aArgsArray[$index];
                $wildcard = false;
                if ((strpos($condition, '*') !== false) || (strpos($condition, '?') !== false)) {
                    // * and ? are wildcard characters.
                    // Use ~* and ~? for literal star and question mark
                    // Code logic doesn't yet handle escaping
                    $condition = trim(ltrim($condition, '=<>'), '"');
                    $wildcard  = true;
                }
                // Loop through arguments
                foreach ($aArgs as $key => $arg) {
                    if ($wildcard) {
                        if (!fnmatch($condition, $arg, FNM_CASEFOLD)) {
                            // Is it a value within our criteria
                            $sumArgs[$key] = 0.0;
                        }
                    } else {
                        if (!is_numeric($arg)) {
                            $arg = PHPExcel_Calculation::wrapResult(strtoupper($arg));
                        }
                        $testCondition = '=' . $arg . $condition;
                        if (!PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
                            // Is it a value within our criteria
                            $sumArgs[$key] = 0.0;
                        }
                    }
                }
            }
            // Return
            return array_sum($sumArgs);
        }

        /**
         * SUMPRODUCT
         * Excel Function:
         *        SUMPRODUCT(value1[,value2[, ...]])
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    mixed $arg,... Data values
         * @return    float
         */
        public static function SUMPRODUCT() {
            $arrayList = func_get_args();
            $wrkArray     = PHPExcel_Calculation_Functions::flattenArray(array_shift($arrayList));
            $wrkCellCount = count($wrkArray);
            for ($i = 0; $i < $wrkCellCount; ++$i) {
                if ((!is_numeric($wrkArray[$i])) || (is_string($wrkArray[$i]))) {
                    $wrkArray[$i] = 0;
                }
            }
            foreach ($arrayList as $matrixData) {
                $array2 = PHPExcel_Calculation_Functions::flattenArray($matrixData);
                $count  = count($array2);
                if ($wrkCellCount != $count) {
                    return PHPExcel_Calculation_Functions::VALUE();
                }
                foreach ($array2 as $i => $val) {
                    if ((!is_numeric($val)) || (is_string($val))) {
                        $val = 0;
                    }
                    $wrkArray[$i] *= $val;
                }
            }
            return array_sum($wrkArray);
        }

        /**
         * SUMSQ
         * SUMSQ returns the sum of the squares of the arguments
         * Excel Function:
         *        SUMSQ(value1[,value2[, ...]])
         * @access    public
         * @category  Mathematical and Trigonometric Functions
         * @param    mixed $arg,... Data values
         * @return    float
         */
        public static function SUMSQ() {
            $returnValue = 0;
            // Loop through arguments
            foreach (PHPExcel_Calculation_Functions::flattenArray(func_get_args()) as $arg) {
                // Is it a numeric value?
                if ((is_numeric($arg)) && (!is_string($arg))) {
                    $returnValue += ($arg * $arg);
                }
            }
            return $returnValue;
        }

        /**
         * SUMX2MY2
         * @param    mixed[] $matrixData1 Matrix #1
         * @param    mixed[] $matrixData2 Matrix #2
         * @return    float
         */
        public static function SUMX2MY2($matrixData1, $matrixData2) {
            $array1 = PHPExcel_Calculation_Functions::flattenArray($matrixData1);
            $array2 = PHPExcel_Calculation_Functions::flattenArray($matrixData2);
            $count  = min(count($array1), count($array2));
            $result = 0;
            for ($i = 0; $i < $count; ++$i) {
                if (((is_numeric($array1[$i])) && (!is_string($array1[$i]))) && ((is_numeric($array2[$i])) && (!is_string($array2[$i])))) {
                    $result += ($array1[$i] * $array1[$i]) - ($array2[$i] * $array2[$i]);
                }
            }
            return $result;
        }

        /**
         * SUMX2PY2
         * @param    mixed[] $matrixData1 Matrix #1
         * @param    mixed[] $matrixData2 Matrix #2
         * @return    float
         */
        public static function SUMX2PY2($matrixData1, $matrixData2) {
            $array1 = PHPExcel_Calculation_Functions::flattenArray($matrixData1);
            $array2 = PHPExcel_Calculation_Functions::flattenArray($matrixData2);
            $count  = min(count($array1), count($array2));
            $result = 0;
            for ($i = 0; $i < $count; ++$i) {
                if (((is_numeric($array1[$i])) && (!is_string($array1[$i]))) && ((is_numeric($array2[$i])) && (!is_string($array2[$i])))) {
                    $result += ($array1[$i] * $array1[$i]) + ($array2[$i] * $array2[$i]);
                }
            }
            return $result;
        }

        /**
         * SUMXMY2
         * @param    mixed[] $matrixData1 Matrix #1
         * @param    mixed[] $matrixData2 Matrix #2
         * @return    float
         */
        public static function SUMXMY2($matrixData1, $matrixData2) {
            $array1 = PHPExcel_Calculation_Functions::flattenArray($matrixData1);
            $array2 = PHPExcel_Calculation_Functions::flattenArray($matrixData2);
            $count  = min(count($array1), count($array2));
            $result = 0;
            for ($i = 0; $i < $count; ++$i) {
                if (((is_numeric($array1[$i])) && (!is_string($array1[$i]))) && ((is_numeric($array2[$i])) && (!is_string($array2[$i])))) {
                    $result += ($array1[$i] - $array2[$i]) * ($array1[$i] - $array2[$i]);
                }
            }
            return $result;
        }

        /**
         * TRUNC
         * Truncates value to the number of fractional digits by number_digits.
         * @param    float $value
         * @param    int   $digits
         * @return    float        Truncated value
         */
        public static function TRUNC($value = 0, $digits = 0) {
            $value  = PHPExcel_Calculation_Functions::flattenSingleValue($value);
            $digits = PHPExcel_Calculation_Functions::flattenSingleValue($digits);
            // Validate parameters
            if ((!is_numeric($value)) || (!is_numeric($digits))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            $digits = floor($digits);
            // Truncate
            $adjust = pow(10, $digits);
            if (($digits > 0) && (rtrim(intval((abs($value) - abs(intval($value))) * $adjust), '0') < $adjust / 10)) {
                return $value;
            }
            return (intval($value * $adjust)) / $adjust;
        }
    }
